Predict Restaurant Menu Items Profitability

import warnings
warnings.filterwarnings("ignore")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report, f1_score

from xgboost import XGBClassifier

import tensorflow as tf
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, LearningRateScheduler

import pickle

dataset = pd.read_csv("./Data/restaurant_menu_optimization_data.csv")

cat_cols = [x for x in dataset.columns if dataset[x].dtypes == 'object']
cat_cols.remove('Profitability')

# Encoding categorical cols
LE = LabelEncoder()

# Label Encoding for Target col
dataset['Profitability'] = LE.fit_transform(dataset['Profitability'])

# One-Hot Encoding for other cat cols
dataset = pd.get_dummies(dataset, columns=['RestaurantID', 'MenuCategory', 'MenuItem', 'Ingredients'])

X = dataset.drop('Profitability', axis=1)
y = dataset['Profitability']

trainX, testX, trainY, testY = train_test_split(X, y, test_size=0.2, random_state=42)

# Function to evaluate model
def evaluate_model(trueY, predY):
    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report

    # Compute accuracy
    accuracy = accuracy_score(trueY, predY)
    
    # Compute precision
    precision = precision_score(trueY, predY, average='weighted')
    
    # Compute recall
    recall = recall_score(trueY, predY, average='weighted')
    
    # Compute F1 score
    f1 = f1_score(trueY, predY, average='weighted')
    
    # Compute confusion matrix
    conf_matrix = confusion_matrix(trueY, predY)
    
    # Generate classification report
    class_report = classification_report(trueY, predY)
    
    # Print the metrics
    print("Model Evaluation Metrics:")
    print("-" * 30)
    print(f"Accuracy: {accuracy:.4f}")
    print(f"Precision: {precision:.4f}")
    print(f"Recall: {recall:.4f}")
    print(f"F1 Score: {f1:.4f}")
    print("\nConfusion Matrix:")
    print(conf_matrix)
    print("\nClassification Report:")
    print(class_report)
    
    # Return the metrics as a dictionary
    metrics = {
        'accuracy': accuracy,
        'precision': precision,
        'recall': recall,
        'f1_score': f1,
        'confusion_matrix': conf_matrix,
        'classification_report': class_report
    }
    
    return metrics

# Function to fit model using GridSearchCV
def fitModel(trainX, testX, trainY, testY, model_name, model_algo, params, CV):
    """
    Fits a machine learning model using GridSearchCV, refits it with the best parameters,
    evaluates it on both training and test data, and stores the evaluation metrics.

    Parameters:
    - trainX: Training features.
    - testX: Test features.
    - trainY: Training labels.
    - testY: Test labels.
    - model_name: Name of the model (string).
    - model_algo: Machine learning algorithm (estimator).
    - params: Dictionary of hyperparameters to tune.
    - CV: Number of cross-validation folds.

    Returns:
    - best_model: The model fitted with the best parameters.
    - best_params: Best hyperparameters found by GridSearchCV.
    - test_metrics: Evaluation metrics on the test set.
    """

    np.random.seed(10)

    print(f"{'-'*75}")
    print("Information")
    print(f"{'-'*75}")
    print(f"Fitting for Model: {model_name}")
    
    grid = GridSearchCV(
        estimator=model_algo,
        param_grid=params,
        scoring='accuracy',
        n_jobs=-1,
        cv=CV,
        verbose=1
    )

    res = grid.fit(trainX, trainY)
    print("Model fitting completed.")
    print(f"{'-'*75}")

    best_params = res.best_params_
    print(f"Found best parameters for model {model_name}: {best_params}")
    print(f"{'-'*75}")

    # Refit the model with the best parameters
    model_algo.set_params(**best_params)
    model_algo.fit(trainX, trainY)
    print(f"Completed refitting the model {model_name} with best parameters.")
    print(f"{'-'*75}")

    # Evaluate on the training data
    print(f"Evaluating {model_name} on the training data.")
    trainY_pred = model_algo.predict(trainX)
    print(f"Evaluation metrics for {model_name} on the training data:")
    train_metrics = evaluate_model(trainY, trainY_pred)
    print(f"{'-'*75}")

    # Evaluate on the test data
    print(f"Evaluating {model_name} on the test data.")
    testY_pred = model_algo.predict(testX)
    print(f"Evaluation metrics for {model_name} on the test data:")
    test_metrics = evaluate_model(testY, testY_pred)
    print(f"{'-'*75}")

    test_accuracy = test_metrics['accuracy']
    if test_accuracy > 0.80:
        model_filename = f"./Models/{model_name}.pkl"
        with open(model_filename, 'wb') as f:
            pickle.dump(model_algo, f)
        print(f"Model {model_name} saved as '{model_name}.pkl'")

    return model_algo, best_params, test_metrics

# Define models and their hyperparameters
models = {
    'RandomForest': {
        'model': RandomForestClassifier(),
        'params': {
            'n_estimators': [10, 50, 100, 500],
            'max_depth': [None, 10, 20, 30]
        }
    },
    'DecisionTree': {
        'model': DecisionTreeClassifier(),
        'params': {
            'max_depth': [None, 10, 20, 30],
            'min_samples_split': [2, 10, 20]
        }
    },
    'XGBoost': {
        'model': XGBClassifier(),
        'params': {
            'n_estimators': [10, 50, 100],
            'max_depth': [3, 6, 9],
            'learning_rate': [0.01, 0.1, 0.2]
        }
    }
}

def createDNNmodel(input_dim, output_dim):

    np.random.seed(10)

    model = Sequential()

    # Hidden Layers
    model = Sequential()
    model.add(Dense(256, input_dim=input_dim, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01)))
    model.add(BatchNormalization())
    model.add(Dropout(0.5))
    model.add(Dense(128, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01)))
    model.add(BatchNormalization())
    model.add(Dropout(0.5))
    model.add(Dense(64, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01)))
    model.add(BatchNormalization())
    model.add(Dropout(0.5))
    model.add(Dense(32, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01)))
    model.add(Dropout(0.5))
    model.add(Dense(32, activation='relu'))

    # Output Layer
    model.add(Dense(output_dim, activation='softmax'))

    # Model Compile
    model.compile(optimizer='adam',
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    
    return model

trainY_encoded = to_categorical(trainY, num_classes=3)
testY_encoded = to_categorical(testY, num_classes=3)